/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Controladores;

import Interfaces.ICtrlPersistencia;
import ObjetosJpa.BandejaSalidaJpa;
import ObjetosJpa.HistorialJpa;
import ObjetosJpa.MensajeJpa;
import ObjetosJpa.UsuarioJpa;
import Proxies.DataAmistad;
import Proxies.DataHistorial;
import Proxies.DataMensaje;
import Proxies.DataUsuario;
import Proxies.DataUsuarioArray;
import Ventanas.Conversacion;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

/**
 *
 * @author Usuario
 */
public class CtrlPersistenciaJpa implements ICtrlPersistencia{

    
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("PersistenciaMovil");
    EntityManager em = emf.createEntityManager();
    
    public void guardarUsuarios(DataUsuario du,EntityManager em) {
        
        
        ArrayList<UsuarioJpa> listJpa = new ArrayList<UsuarioJpa>();

        em.getTransaction().begin();
        if (!existeUsuario(du.getCorreo(),em)) {
            UsuarioJpa usu = new UsuarioJpa();
            usu.setCorreo(du.getCorreo());
            usu.setImagen(du.getImagen());
            usu.setNick(du.getNick());
            usu.setNombre(du.getNombre());
            usu.setPais(du.getPais());
            usu.setPrimeravez(false);
            guardarAmigos(usu, du,em);
            em.persist(usu);
        }

        else
        {
            if(!du.getCorreo().isEmpty())
            {   
            Query q = em.createQuery("SELECT a FROM UsuarioJpa a WHERE a.correo = :correo");
            UsuarioJpa res =(UsuarioJpa) q.setParameter("correo",du.getCorreo()).getSingleResult();
            res.setPrimeravez(false);
            guardarAmigos(res, du,em);
            em.merge(res);
            }
        }
        
        em.getTransaction().commit();
       
        List usuarios2 = em.createQuery("SELECT a FROM UsuarioJpa a").getResultList();
     
    }
    
    private void guardarAmigos(UsuarioJpa usu,DataUsuario du,EntityManager em){
        
        UsuarioJpa usJ = usu;
        List<DataAmistad> amigos = du.getAmigos();
        Iterator<DataAmistad> it = amigos.iterator();
        ArrayList<UsuarioJpa> amigosJpa = new ArrayList<UsuarioJpa>();
        
        while(it.hasNext())
        {
            DataAmistad dat = it.next();
            DataUsuario datU;
            if(dat.getAmigo1().getCorreo().equals(du.getCorreo()))
                datU = dat.getAmigo2();
            else
                datU = dat.getAmigo1();
            
            UsuarioJpa ju;
            if (!existeUsuario(datU.getCorreo(), em)) {
                ju = new UsuarioJpa();
                ju.setCorreo(datU.getCorreo());
                ju.setNick(datU.getNick());
                ju.setNombre(datU.getNombre());
                ju.setImagen(datU.getImagen());
                ju.setPrimeravez(true);
                em.persist(ju);
            } else {
                Query q = em.createQuery("SELECT a FROM UsuarioJpa a WHERE a.correo = :correo");
                ju = (UsuarioJpa) q.setParameter("correo", datU.getCorreo()).getSingleResult();
            }
            
            amigosJpa.add(ju);
        }
        usJ.setAmigos(amigosJpa);
    }
    
    @Override
    public void guardarMensajes(String us,DataUsuario du){
        
        
        em.getTransaction().begin();
        Query q = em.createQuery("SELECT a FROM UsuarioJpa a WHERE a.correo = :correo");
        UsuarioJpa usJ = (UsuarioJpa) q.setParameter("correo",us).getSingleResult();
        List<DataHistorial> hist = du.getHistorial();
        Iterator<DataHistorial>it  = hist.iterator();
        ArrayList<MensajeJpa>mensaj = new ArrayList<MensajeJpa>();
        ArrayList<HistorialJpa>historiales = new ArrayList<HistorialJpa>();
        HistorialJpa hisj = new HistorialJpa();
        while(it.hasNext()){
            
            DataHistorial next = it.next();
            hisj.setIdAmigo(next.getIdAmigo());
           
            List<DataMensaje> mensajes = next.getMensajes();
            Iterator<DataMensaje> itera = mensajes.iterator();
            
            while(itera.hasNext()){
                
                DataMensaje men = itera.next();
                MensajeJpa menj = new MensajeJpa();
                menj.setEmisor(men.getEmisor());
                menj.setMsj(men.getMsj());
                mensaj.add(menj);
                em.persist(menj);
            }
            hisj.setMensajes(mensaj);
        }
        em.persist(hisj);
        historiales.add(hisj);
        usJ.setHistorial(historiales);
        em.merge(usJ);
        em.getTransaction().commit();
        
    }
    
    private boolean existeUsuario(String usuario,EntityManager em){
        
        List usuarios = em.createQuery("SELECT a FROM UsuarioJpa a").getResultList();
        HashMap<String,UsuarioJpa> dicUsu = new HashMap<String, UsuarioJpa>();
        Iterator<UsuarioJpa> itusu = usuarios.iterator();
        while(itusu.hasNext()){
            
            UsuarioJpa jpaU = itusu.next();
            dicUsu.put(jpaU.getCorreo(), jpaU);

        }
        return (dicUsu.containsKey(usuario));
        
    }
  
    

    @Override
    public void guardarHistoriales(HashMap<String, DataHistorial> hist) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public UsuarioJpa cargarDatos(String correo) {
       
        UsuarioJpa usj = null;
        if (existeUsuario(correo, em)) {

            Query q = em.createQuery("SELECT a FROM UsuarioJpa a WHERE a.correo = :correo");
            usj = (UsuarioJpa) q.setParameter("correo", correo).getSingleResult();
        } 
        
        return usj;
        
    }

    @Override
    public void guardarDatos(DataUsuario usu) {

        
        guardarUsuarios(usu,em);
    
    }
    
    @Override
  
    public void guardarBandejaSalida(ArrayList<Conversacion> listconv,String usu){
      
        Iterator<Conversacion> iterator = listconv.iterator();
        em.getTransaction().begin();
        while (iterator.hasNext()) {

            Conversacion conv = iterator.next();

            BandejaSalidaJpa bs = new BandejaSalidaJpa();
            bs.setChatID(conv.getIdChat());
            Iterator<DataMensaje> it = conv.getBandejaSalida().iterator();
            ArrayList<MensajeJpa> listMen = new ArrayList<MensajeJpa>();
            while (it.hasNext()) {

                DataMensaje dmen = it.next();
                MensajeJpa men = new MensajeJpa();
                men.setEmisor(dmen.getEmisor());
                men.setMsj(dmen.getMsj());
                em.persist(men);
                listMen.add(men);
            }
            bs.setMensajes(listMen);
            UsuarioJpa usuJpa = null;
            em.persist(bs);
            if (existeUsuario(usu, em)) {

                Query q = em.createQuery("SELECT a FROM UsuarioJpa a WHERE a.correo = :correo");
                usuJpa = (UsuarioJpa) q.setParameter("correo", usu).getSingleResult();
                usuJpa.getBandejaSalida().add(bs);
                em.merge(usuJpa);
            }
        }

        em.getTransaction().commit();
    }

    @Override
    public void close() {
        em.close();
    }

    @Override
    public void vaciarBandejaSalida(String usu) {
        
    if(existeUsuario(usu, em))
        {
            em.getTransaction().begin();
            Query q = em.createQuery("SELECT a FROM UsuarioJpa a WHERE a.correo = :correo");
            UsuarioJpa usuJpa = (UsuarioJpa) q.setParameter("correo", usu).getSingleResult();
            usuJpa.getBandejaSalida().clear();
            em.merge(usuJpa);
            em.getTransaction().commit();
        }  
    }
    
}
